package beeboxes;

import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;

public class TextsUtils {
    public static String bytesToHexString(byte[] src, int offset, int len) {
        StringBuilder stringBuilder = new StringBuilder("");
        if (src == null || src.length <= 0 || src.length < len) {
            return null;
        }
        for (int i = offset; i < len; i++) {
            int v = src[i] & 0xFF;
            String hv = Integer.toHexString(v);
            stringBuilder.append("0x");
            if (hv.length() < 2) {
                stringBuilder.append(0);
            }

            stringBuilder.append(hv.toUpperCase());
            stringBuilder.append(",");
        }
        return stringBuilder.toString();
    }

    public static byte[] strToByteArray(String str) {
        if (str == null) {
            return null;
        }
        byte[] byteArray = str.getBytes();
        return byteArray;
    }

    public static String byteArrayToStr(byte[] byteArray) {
        int validIndex = 0, validIndexBak = 0;
        if (byteArray == null) {
            return null;
        }
        //Log.d(TAG, "byteArray.length=" + byteArray.length);
        validIndex = byteArray.length;
        //Log.d(TAG, "byteArray validIndex=" + validIndex);
        String str = new String(byteArray, 0, validIndex);
        return str;
    }

//    public static String byteArrayToStr(byte[] byteArray) {
//        int validIndex = 0, validIndexBak = 0;
//        if (byteArray == null) {
//            return null;
//        }
//        //Log.d(TAG, "byteArray.length=" + byteArray.length);
//        for (validIndex = 0; validIndex < byteArray.length; validIndex++) {
//            if (byteArray[validIndex] == '\0') {
//                break;
//            }
//        }
//        //Log.d(TAG, "byteArray validIndex=" + validIndex);
//        //delete the next line break of the end string
//        if (validIndex >= byteArray.length) {
//            validIndexBak = validIndex - 1;
//        } else {
//            validIndexBak = validIndex;
//        }
//        for (; validIndexBak >= 0; validIndexBak--) {
//            if (byteArray[validIndexBak] == '\n') {
//                break;
//            }
//        }
//        //if find the end string, set the correct index, else do nothings
//        if (validIndexBak >= 0) {
//            validIndex = validIndexBak;
//        } else {
//            //Log.e(TAG, "not find the line break, using the whole string");
//        }
//        //Log.d(TAG, "byteArray validIndex=" + validIndex);
//        String str = new String(byteArray, 0, validIndex);
//        return str;
//    }

    public static void byteArrayClean(byte[] byteArray) {
        int i = 0;
        if (byteArray == null) {
            return;
        }
        for (i = 0; i < byteArray.length; i++) {
            byteArray[i] = '\0';
        }
        return;
    }

    public static void byteArrayClean(byte[] byteArray, int offset, int length) {
        int i = 0;
        if (null == byteArray|| byteArray.length <= 0 || byteArray.length < length) {
            return;
        }
        for (i = offset; i < length; i++) {
            byteArray[i] = '\0';
        }
        return;
    }

    public static byte[] getBytes(char[] chars) {
        Charset cs = Charset.forName("UTF-8");
        CharBuffer cb = CharBuffer.allocate(chars.length);
        cb.put(chars);
        cb.flip();
        ByteBuffer bb = cs.encode(cb);
        return bb.array();
    }

    public static char[] getChars(byte[] bytes) {
        Charset cs = Charset.forName("UTF-8");
        ByteBuffer bb = ByteBuffer.allocate(bytes.length);
        bb.put(bytes).flip();
        CharBuffer cb = cs.decode(bb);
        return cb.array();
    }

    public static byte[] charToByte(char c) {
        byte[] b = new byte[2];
        b[0] = (byte) ((c & 0xFF00) >> 8);
        b[1] = (byte) (c & 0xFF);
        return b;
    }

    public static char byteToChar(byte[] b) {
        int hi = (b[0] & 0xFF) << 8;
        int lo = b[1] & 0xFF;
        return (char) (hi | lo);
    }
}
